#ifndef THREADPOOL_H_
#define THREADPOOL_H_

#include <functional>
#include <memory>
#include <atomic>
#include <vector>
#include "TaskQueue.h"
#include "ThreadGroup.h"
#include "TaskExecutor.h"

namespace toolkit {

/**
 * @brief 线程池类，组件管理者，将任务队列以及线程组关联起来使用
 */
class ThreadPool : public TaskExecutor {
public:
    using Ptr = std::shared_ptr<ThreadPool>;
    
    /**
     * @brief 构造函数
     * @param thread_num 线程数量
     */
    ThreadPool(size_t thread_num = 1) : _thread_num(thread_num) {
        // 创建线程
        for (size_t i = 0; i < thread_num; ++i) {
            _thread_group.createThread([this]() {
                run();
            });
        }
    }
    
    /**
     * @brief 析构函数
     */
    ~ThreadPool() override {
        shutdown();
    }
    
    /**
     * @brief 关闭线程池
     */
    void shutdown() {
        if (_exit_flag.exchange(true)) {
            return;
        }
        
        // 通知所有线程退出
        _task_queue.push_exit(_thread_num);
        
        // 等待所有线程退出
        _thread_group.joinAll();
    }
    
    /**
     * @brief 获取线程数量
     */
    size_t size() const {
        return _thread_num;
    }
    
    /**
     * @brief 异步执行任务
     * @param task 任务函数
     * @param may_sync 是否允许同步执行
     * @return 任务取消对象
     */
    TaskCancelable::Ptr async(Task task, bool may_sync = true) override {
        if (may_sync && _thread_num == 0) {
            // 同步执行
            task();
            return nullptr;
        }
        
        if (_exit_flag) {
            // 线程池已关闭
            return nullptr;
        }
        
        auto cancelable = std::make_shared<TaskCancelableImp>();
        auto wrapped_task = [cancelable, task]() {
            if (!cancelable->isCanceled()) {
                task();
            }
        };
        
        _task_queue.push_task(std::move(wrapped_task));
        return cancelable;
    }
    
    /**
     * @brief 异步执行任务，优先执行
     * @param task 任务函数
     * @param may_sync 是否允许同步执行
     * @return 任务取消对象
     */
    TaskCancelable::Ptr async_first(Task task, bool may_sync = true) override {
        if (may_sync && _thread_num == 0) {
            // 同步执行
            task();
            return nullptr;
        }
        
        if (_exit_flag) {
            // 线程池已关闭
            return nullptr;
        }
        
        auto cancelable = std::make_shared<TaskCancelableImp>();
        auto wrapped_task = [cancelable, task]() {
            if (!cancelable->isCanceled()) {
                task();
            }
        };
        
        _task_queue.push_task_first(std::move(wrapped_task));
        return cancelable;
    }
    
    /**
     * @brief 获取任务执行器负载
     * @return 负载值
     */
    int getLoad() override {
        return _thread_load.getLoad();
    }
    
private:
    /**
     * @brief 线程函数
     */
    void run() {
        Task task;
        while (!_exit_flag) {
            // 获取任务
            if (!_task_queue.get_task(task)) {
                // 队列为空但信号量被触发，可能是退出信号
                continue;
            }
            
            // 执行任务
            _thread_load.addLoad();
            try {
                task();
            } catch (std::exception &e) {
                // 处理任务执行异常
            } catch (...) {
                // 处理未知异常
            }
            _thread_load.reduceLoad();
        }
    }
    
private:
    size_t _thread_num;
    std::atomic<bool> _exit_flag{false};
    ThreadLoadCounter _thread_load;
    TaskQueue<Task> _task_queue;
    ThreadGroup _thread_group;
};

} /* namespace toolkit */

#endif /* THREADPOOL_H_ */